home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / popen2.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  9KB  |  270 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """Spawn a command with pipes to its stdin, stdout, and optionally stderr.
  5.  
  6. The normal os.popen(cmd, mode) call spawns a shell command and provides a
  7. file interface to just the input or output of the process depending on
  8. whether mode is 'r' or 'w'.  This module provides the functions popen2(cmd)
  9. and popen3(cmd) which return two or three pipes to the spawned command.
  10. """
  11. import os
  12. import sys
  13. __all__ = [
  14.     'popen2',
  15.     'popen3',
  16.     'popen4']
  17.  
  18. try:
  19.     MAXFD = os.sysconf('SC_OPEN_MAX')
  20. except (AttributeError, ValueError):
  21.     MAXFD = 256
  22.  
  23. _active = []
  24.  
  25. def _cleanup():
  26.     for inst in _active[:]:
  27.         inst.poll()
  28.     
  29.  
  30.  
  31. class Popen3:
  32.     '''Class representing a child process.  Normally instances are created
  33.     by the factory functions popen2() and popen3().'''
  34.     sts = -1
  35.     
  36.     def __init__(self, cmd, capturestderr = False, bufsize = -1):
  37.         """The parameter 'cmd' is the shell command to execute in a
  38.         sub-process.  On UNIX, 'cmd' may be a sequence, in which case arguments
  39.         will be passed directly to the program without shell intervention (as
  40.         with os.spawnv()).  If 'cmd' is a string it will be passed to the shell
  41.         (as with os.system()).   The 'capturestderr' flag, if true, specifies
  42.         that the object should capture standard error output of the child
  43.         process.  The default is false.  If the 'bufsize' parameter is
  44.         specified, it specifies the size of the I/O buffers to/from the child
  45.         process."""
  46.         _cleanup()
  47.         (p2cread, p2cwrite) = os.pipe()
  48.         (c2pread, c2pwrite) = os.pipe()
  49.         if capturestderr:
  50.             (errout, errin) = os.pipe()
  51.         
  52.         self.pid = os.fork()
  53.         if self.pid == 0:
  54.             os.dup2(p2cread, 0)
  55.             os.dup2(c2pwrite, 1)
  56.             if capturestderr:
  57.                 os.dup2(errin, 2)
  58.             
  59.             self._run_child(cmd)
  60.         
  61.         os.close(p2cread)
  62.         self.tochild = os.fdopen(p2cwrite, 'w', bufsize)
  63.         os.close(c2pwrite)
  64.         self.fromchild = os.fdopen(c2pread, 'r', bufsize)
  65.         if capturestderr:
  66.             os.close(errin)
  67.             self.childerr = os.fdopen(errout, 'r', bufsize)
  68.         else:
  69.             self.childerr = None
  70.         _active.append(self)
  71.  
  72.     
  73.     def _run_child(self, cmd):
  74.         if isinstance(cmd, basestring):
  75.             cmd = [
  76.                 '/bin/sh',
  77.                 '-c',
  78.                 cmd]
  79.         
  80.         for i in range(3, MAXFD):
  81.             
  82.             try:
  83.                 os.close(i)
  84.             continue
  85.             except OSError:
  86.                 continue
  87.             
  88.  
  89.         
  90.         
  91.         try:
  92.             os.execvp(cmd[0], cmd)
  93.         finally:
  94.             os._exit(1)
  95.  
  96.  
  97.     
  98.     def poll(self):
  99.         """Return the exit status of the child process if it has finished,
  100.         or -1 if it hasn't finished yet."""
  101.         if self.sts < 0:
  102.             
  103.             try:
  104.                 (pid, sts) = os.waitpid(self.pid, os.WNOHANG)
  105.                 if pid == self.pid:
  106.                     self.sts = sts
  107.                     _active.remove(self)
  108.             except os.error:
  109.                 pass
  110.             except:
  111.                 None<EXCEPTION MATCH>os.error
  112.             
  113.  
  114.         None<EXCEPTION MATCH>os.error
  115.         return self.sts
  116.  
  117.     
  118.     def wait(self):
  119.         '''Wait for and return the exit status of the child process.'''
  120.         if self.sts < 0:
  121.             (pid, sts) = os.waitpid(self.pid, 0)
  122.             if pid == self.pid:
  123.                 self.sts = sts
  124.                 _active.remove(self)
  125.             
  126.         
  127.         return self.sts
  128.  
  129.  
  130.  
  131. class Popen4(Popen3):
  132.     childerr = None
  133.     
  134.     def __init__(self, cmd, bufsize = -1):
  135.         _cleanup()
  136.         (p2cread, p2cwrite) = os.pipe()
  137.         (c2pread, c2pwrite) = os.pipe()
  138.         self.pid = os.fork()
  139.         if self.pid == 0:
  140.             os.dup2(p2cread, 0)
  141.             os.dup2(c2pwrite, 1)
  142.             os.dup2(c2pwrite, 2)
  143.             self._run_child(cmd)
  144.         
  145.         os.close(p2cread)
  146.         self.tochild = os.fdopen(p2cwrite, 'w', bufsize)
  147.         os.close(c2pwrite)
  148.         self.fromchild = os.fdopen(c2pread, 'r', bufsize)
  149.         _active.append(self)
  150.  
  151.  
  152. if sys.platform[:3] == 'win' or sys.platform == 'os2emx':
  153.     del Popen3
  154.     del Popen4
  155.     
  156.     def popen2(cmd, bufsize = -1, mode = 't'):
  157.         """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' may
  158.         be a sequence, in which case arguments will be passed directly to the
  159.         program without shell intervention (as with os.spawnv()). If 'cmd' is a
  160.         string it will be passed to the shell (as with os.system()). If
  161.         'bufsize' is specified, it sets the buffer size for the I/O pipes. The
  162.         file objects (child_stdout, child_stdin) are returned."""
  163.         (w, r) = os.popen2(cmd, mode, bufsize)
  164.         return (r, w)
  165.  
  166.     
  167.     def popen3(cmd, bufsize = -1, mode = 't'):
  168.         """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' may
  169.         be a sequence, in which case arguments will be passed directly to the
  170.         program without shell intervention (as with os.spawnv()). If 'cmd' is a
  171.         string it will be passed to the shell (as with os.system()). If
  172.         'bufsize' is specified, it sets the buffer size for the I/O pipes. The
  173.         file objects (child_stdout, child_stdin, child_stderr) are returned."""
  174.         (w, r, e) = os.popen3(cmd, mode, bufsize)
  175.         return (r, w, e)
  176.  
  177.     
  178.     def popen4(cmd, bufsize = -1, mode = 't'):
  179.         """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' may
  180.         be a sequence, in which case arguments will be passed directly to the
  181.         program without shell intervention (as with os.spawnv()). If 'cmd' is a
  182.         string it will be passed to the shell (as with os.system()). If
  183.         'bufsize' is specified, it sets the buffer size for the I/O pipes. The
  184.         file objects (child_stdout_stderr, child_stdin) are returned."""
  185.         (w, r) = os.popen4(cmd, mode, bufsize)
  186.         return (r, w)
  187.  
  188. else:
  189.     
  190.     def popen2(cmd, bufsize = -1, mode = 't'):
  191.         """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' may
  192.         be a sequence, in which case arguments will be passed directly to the
  193.         program without shell intervention (as with os.spawnv()). If 'cmd' is a
  194.         string it will be passed to the shell (as with os.system()). If
  195.         'bufsize' is specified, it sets the buffer size for the I/O pipes. The
  196.         file objects (child_stdout, child_stdin) are returned."""
  197.         inst = Popen3(cmd, False, bufsize)
  198.         return (inst.fromchild, inst.tochild)
  199.  
  200.     
  201.     def popen3(cmd, bufsize = -1, mode = 't'):
  202.         """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' may
  203.         be a sequence, in which case arguments will be passed directly to the
  204.         program without shell intervention (as with os.spawnv()). If 'cmd' is a
  205.         string it will be passed to the shell (as with os.system()). If
  206.         'bufsize' is specified, it sets the buffer size for the I/O pipes. The
  207.         file objects (child_stdout, child_stdin, child_stderr) are returned."""
  208.         inst = Popen3(cmd, True, bufsize)
  209.         return (inst.fromchild, inst.tochild, inst.childerr)
  210.  
  211.     
  212.     def popen4(cmd, bufsize = -1, mode = 't'):
  213.         """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' may
  214.         be a sequence, in which case arguments will be passed directly to the
  215.         program without shell intervention (as with os.spawnv()). If 'cmd' is a
  216.         string it will be passed to the shell (as with os.system()). If
  217.         'bufsize' is specified, it sets the buffer size for the I/O pipes. The
  218.         file objects (child_stdout_stderr, child_stdin) are returned."""
  219.         inst = Popen4(cmd, bufsize)
  220.         return (inst.fromchild, inst.tochild)
  221.  
  222.     __all__.extend([
  223.         'Popen3',
  224.         'Popen4'])
  225.  
  226. def _test():
  227.     cmd = 'cat'
  228.     teststr = 'ab cd\n'
  229.     if os.name == 'nt':
  230.         cmd = 'more'
  231.     
  232.     expected = teststr.strip()
  233.     print 'testing popen2...'
  234.     (r, w) = popen2(cmd)
  235.     w.write(teststr)
  236.     w.close()
  237.     got = r.read()
  238.     if got.strip() != expected:
  239.         raise ValueError('wrote %r read %r' % (teststr, got))
  240.     
  241.     print 'testing popen3...'
  242.     
  243.     try:
  244.         (r, w, e) = popen3([
  245.             cmd])
  246.     except:
  247.         (r, w, e) = popen3(cmd)
  248.  
  249.     w.write(teststr)
  250.     w.close()
  251.     got = r.read()
  252.     if got.strip() != expected:
  253.         raise ValueError('wrote %r read %r' % (teststr, got))
  254.     
  255.     got = e.read()
  256.     if got:
  257.         raise ValueError('unexpected %r on stderr' % (got,))
  258.     
  259.     for inst in _active[:]:
  260.         inst.wait()
  261.     
  262.     if _active:
  263.         raise ValueError('_active not empty')
  264.     
  265.     print 'All OK'
  266.  
  267. if __name__ == '__main__':
  268.     _test()
  269.  
  270.